/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.academik.controller;

import java.io.Serializable;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import org.academik.model.Alumno;
import org.academik.model.Estadoalumno;
import org.academik.model.Padre;
import org.academik.model.PadreAlumno;
import org.academik.model.PadreAlumnoId;
import org.academik.model.Persona;
import org.academik.model.Problemasalud;
import org.academik.model.Sacalumno;
import org.academik.model.SacalumnoId;
import org.academik.model.Ubicacion;
import org.academik.util.FacesUtil;
import org.academik.util.HibernateUtil;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import org.primefaces.event.SelectEvent;

/**
 *
 * @author Javier
 */
@ManagedBean(name = "alumnoBean")
@ViewScoped
public class AlumnoBean extends AbstractViewScopedBean implements Serializable {

    /** Declaracion de variables*/
    private ArrayList listaAlumnos;
    private Persona persona;
    private Long selectedDepartamento;
    private ArrayList<SelectItem> listaUbicaciones;
    private Alumno alumno;
    private Object[] selectedAlumno;
    private Long selectedUbicacion;
    private Boolean bautismo;
    private Boolean comunion;
    private Boolean confirmacion;
    private Problemasalud problemaSalud;
    private ArrayList<Problemasalud> problemasDeSalud;
    private Problemasalud selectedProblema;
    private Estadoalumno estadoAlumno;
    private ArrayList<Estadoalumno> listaEstadoAlumnos;
    private Persona personaPadre;
    private Persona personaMadre;
    private String padre;
    private String madre;
    private String buscarPadre;
    private String buscarMadre;
    private String tempEstadoPadres;

    /** Creates a new instance of AlumnoBean */
    public AlumnoBean() {
        this.nuevo();
    }

    @Override
    public void crear() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void eliminar() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void cargarOpciones() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void cargarOpciones(int id) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void buscar() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void modificar() {
        /* Limpiando variables antes de usarlas */
        this.limpiar();
        /* para que cuando sea null la ubicacion 
         * de los alumnos no muestre basura */

        this.alumno = (Alumno) this.selectedAlumno[0];
        this.persona = (Persona) this.selectedAlumno[1];

        if (this.getDepartamentoAlumno(this.alumno.getIdAlumno()) != null) {
            this.selectedDepartamento = this.getDepartamentoAlumno(this.alumno.getIdAlumno()).longValue();
            this.onSelectDepartamento();
            this.selectedUbicacion = this.getMunicipioAlumno(this.alumno.getIdAlumno()).longValue();
        }

        if (this.getSacramentosAlumno(this.alumno.getIdAlumno()) != null) {
            ArrayList lista = this.getSacramentosAlumno(this.alumno.getIdAlumno());
            Iterator iter = lista.iterator();
            while (iter.hasNext()) {
                String sacramento = (String) iter.next();
                if (sacramento.equals("Bautismo")) {
                    this.bautismo = true;
                }
                if (sacramento.equals("Comunion")) {
                    this.comunion = true;
                }
                if (sacramento.equals("Confirmacion")) {
                    this.confirmacion = true;
                }
            }
        }

        if (this.getProblemasDeSalud(this.alumno) != null) {
            this.problemasDeSalud = this.getProblemasDeSalud(this.alumno);
        }
    }

    @Override
    public void cargarResgistros() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public void nuevo() {
        this.listaAlumnos = new ArrayList();
        this.persona = new Persona();
        this.alumno = new Alumno();
        this.selectedAlumno = null;
        this.selectedUbicacion = null;
        this.bautismo = false;
        this.comunion = false;
        this.confirmacion = false;
        this.problemaSalud = new Problemasalud();
        this.problemasDeSalud = new ArrayList<Problemasalud>();
        this.selectedProblema = null;

        this.estadoAlumno = new Estadoalumno();
        this.listaEstadoAlumnos = new ArrayList<Estadoalumno>();
        this.personaPadre = new Persona();
        this.personaMadre = new Persona();
        this.padre = null;
        this.madre = null;
        this.buscarPadre = null;
        this.buscarMadre = null;
        this.tempEstadoPadres = null;
        this.populateAlumnos();
    }

    public void cambiarPadres() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = null;
        try {
            tx = (Transaction) session.beginTransaction();
            if (!this.buscarPadre.equals("")) {
                if (this.personaPadre != null) { //Quitar?? Proba haber si furula y si es asi... quitalo de la madre tmb...
                    String sql = "SELECT p FROM Persona p "
                            + "WHERE CONCAT_WS(' ',p.vcNombres,p.vcApellidos) "
                            + "LIKE :nombre";
                    Query query = session.createQuery(sql);
                    query.setParameter("nombre", this.padre);
                    Persona tempPersona = (Persona) query.uniqueResult();

                    sql = "SELECT p "
                            + "FROM Padre p "
                            + "WHERE p.persona = :parametro";
                    query = session.createQuery(sql);
                    query.setParameter("parametro", tempPersona);

                    Padre tempPadreViejo = (Padre) query.uniqueResult();
                    /**Hasta aqui ya tengo al padre que voy a modificar*/
                    sql = "SELECT p FROM Padre p "
                            + "WHERE p.persona = :persona";
                    query = session.createQuery(sql);
                    query.setParameter("persona", this.personaPadre);

                    if (query.uniqueResult() != null) { //Si el padre esta registrado en la BD haga lo que sigue...
                        Padre tempPadreNuevo = (Padre) query.uniqueResult();
                        tempPadreNuevo.setVcEstadoCivil(this.tempEstadoPadres);
                        session.saveOrUpdate(tempPadreNuevo);

                        sql = "SELECT p FROM PadreAlumno p "
                                + "WHERE p.padre = :padre "
                                + "AND p.alumno = :alumno";
                        query = session.createQuery(sql);
                        query.setParameter("padre", tempPadreViejo);
                        query.setParameter("alumno", this.alumno);
                        PadreAlumno tempPadreAlumno = (PadreAlumno) query.uniqueResult();

                        sql = "UPDATE PadreAlumno p "
                                + "SET p.padre = :padre "
                                + "WHERE p.alumno = :alumno AND p.padre = :padreViejo";
                        query = session.createQuery(sql);
                        query.setParameter("padre", tempPadreNuevo);
                        query.setParameter("alumno", this.alumno);
                        query.setParameter("padreViejo", tempPadreAlumno.getPadre());
                        query.executeUpdate();
                    } else { //Sino existe registrado en la tabla Padre haga lo siguiente...
                        sql = "DELETE FROM PadreAlumno "
                                + "WHERE alumno = :alumno "
                                + "AND padre = :padreViejo";
                        query = session.createQuery(sql);
                        query.setParameter("alumno", this.alumno);
                        query.setParameter("padreViejo", tempPadreViejo);
                        query.executeUpdate(); //Elimine el registro del padre viejo relacionado al alumno en PadreAlumno

                        this.personaPadre.setBoPadre(true);
                        session.saveOrUpdate(this.personaPadre); //Actualice boPadre=true para identificarlo que es padre

                        Padre tempPadreNuevo = new Padre();
                        tempPadreNuevo.setVcEstadoCivil(this.tempEstadoPadres);
                        tempPadreNuevo.setPersona(this.personaPadre);
                        session.save(tempPadreNuevo);       //Registrelo

                        PadreAlumnoId idPadreAlumno = new PadreAlumnoId();
                        idPadreAlumno.setAlumnoIdAlumno(this.alumno.getIdAlumno());
                        idPadreAlumno.setPadreIdPadre(tempPadreNuevo.getIdPadre());
                        PadreAlumno padreAlumno = new PadreAlumno();
                        padreAlumno.setId(idPadreAlumno);
                        padreAlumno.setVcParentesco("Padre");
                        padreAlumno.setPadre(tempPadreNuevo);
                        session.save(padreAlumno);  //Y vinculelo con el alumno
                    }
                }
            }

            session.flush();

            if (!this.buscarMadre.equals("")) {
                if (this.personaMadre != null) {
                    String sql = "SELECT p FROM Persona p "
                            + "WHERE CONCAT_WS(' ',p.vcNombres,p.vcApellidos) "
                            + "LIKE :nombre";
                    Query query = session.createQuery(sql);
                    query.setParameter("nombre", this.madre);
                    Persona tempPersona = (Persona) query.uniqueResult();

                    sql = "SELECT p "
                            + "FROM Padre p "
                            + "WHERE p.persona = :parametro";
                    query = session.createQuery(sql);
                    query.setParameter("parametro", tempPersona);
                    Padre tempMadreVieja = (Padre) query.uniqueResult();

                    //*Hasta aqui ya tengo al padre que voy a modificar
                    sql = "SELECT p FROM Padre p "
                            + "WHERE p.persona = :persona";
                    query = session.createQuery(sql);
                    query.setParameter("persona", this.personaMadre);

                    if (query.uniqueResult() != null) { //Si la madre esta registrado en la BD haga lo que sigue...
                        Padre tempMadreNueva = (Padre) query.uniqueResult();
                        tempMadreNueva.setVcEstadoCivil(this.tempEstadoPadres);
                        session.saveOrUpdate(tempMadreNueva);

                        sql = "SELECT p FROM PadreAlumno p "
                                + "WHERE p.padre = :padre "
                                + "AND p.alumno = :alumno";
                        query = session.createQuery(sql);
                        query.setParameter("padre", tempMadreVieja);
                        query.setParameter("alumno", this.alumno);
                        PadreAlumno tempMadreAlumno = (PadreAlumno) query.uniqueResult();

                        sql = "UPDATE PadreAlumno p "
                                + "SET p.padre = :padre "
                                + "WHERE p.alumno = :alumno AND p.padre = :padreViejo";
                        query = session.createQuery(sql);
                        query.setParameter("padre", tempMadreNueva);
                        query.setParameter("alumno", this.alumno);
                        query.setParameter("padreViejo", tempMadreAlumno.getPadre());
                        query.executeUpdate();
                    } else { //Sino existe registrado en la tabla Padre haga lo siguiente...
                        sql = "DELETE FROM PadreAlumno "
                                + "WHERE alumno = :alumno "
                                + "AND padre = :padreViejo";
                        query = session.createQuery(sql);
                        query.setParameter("alumno", this.alumno);
                        query.setParameter("padreViejo", tempMadreVieja);
                        query.executeUpdate(); //Elimine el registro del padre viejo relacionado al alumno en PadreAlumno

                        this.personaMadre.setBoPadre(true);
                        session.saveOrUpdate(this.personaMadre); //Actualice boPadre=true para identificarlo que es padre

                        Padre tempMadreNueva = new Padre();
                        tempMadreNueva.setVcEstadoCivil(this.tempEstadoPadres);
                        tempMadreNueva.setPersona(this.personaMadre);
                        session.save(tempMadreNueva);       //Registrelo

                        PadreAlumnoId idMadreAlumno = new PadreAlumnoId();
                        idMadreAlumno.setAlumnoIdAlumno(this.alumno.getIdAlumno());
                        idMadreAlumno.setPadreIdPadre(tempMadreNueva.getIdPadre());
                        PadreAlumno madreAlumno = new PadreAlumno();
                        madreAlumno.setId(idMadreAlumno);
                        madreAlumno.setVcParentesco("Madre");
                        madreAlumno.setPadre(tempMadreNueva);
                        session.save(madreAlumno);  //Y vinculelo con el alumno
                    }
                }
            }
            session.flush();
            session.clear();
            tx.commit();
            this.nuevo();
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO, "Información:", "Los padres fueron cambiados satisfactoriamente"));
        } catch (HibernateException e) {
            tx.rollback();
            FacesUtil.hibernateException(e);
            e.printStackTrace();
        } finally {
            session.close();
        }
    }

    /** Metodo para limpiar frmPadre y frmMadre*/
    public void limpiarFrmPadres() {
        String limpiar = (String) UIComponent.getCurrentComponent(FacesContext.getCurrentInstance()).getAttributes().get("limpiar");
        if ("limpiarPadre".equals(limpiar)) {
            this.buscarPadre = null;
            this.personaPadre = new Persona();
        } else {
            this.buscarMadre = null;
            this.personaMadre = new Persona();
        }
    }

    /*Metodo para el autoComplete*/
    public void onSelectNomPadre(SelectEvent event) {
        this.onKeyPress();
    }

    /**Cargar datos en los formularios una vez se seleccione el nombre del campo de tipo autocomplete*/
    private void onKeyPress() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        String tipoPersona = (String) UIComponent.getCurrentComponent(FacesContext.getCurrentInstance()).getAttributes().get("tipoPersona");
        String sql = "SELECT p FROM Persona p "
                + "WHERE CONCAT_WS(' ',p.vcNombres,p.vcApellidos) "
                + "LIKE :valor ";

        Query query = session.createQuery(sql);
        query.setMaxResults(1);

        if ("Padre".equals(tipoPersona)) { /*Para que busque si es madre o padre o responsable*/
            query.setParameter("valor", "%" + this.buscarPadre + "%");
        } else {
            query.setParameter("valor", "%" + this.buscarMadre + "%");
        }

        if ("Padre".equals(tipoPersona)) {
            this.personaPadre = new Persona();
            this.personaPadre = (Persona) query.uniqueResult();
        } else {
            this.personaMadre = new Persona();
            this.personaMadre = (Persona) query.uniqueResult();
        }
        session.close();
    }

    /** Motrar los padres que estan relacionados actualmente al alumno*/
    public void cargarPadres() {
        this.alumno = new Alumno();
        this.alumno = (Alumno) this.selectedAlumno[0];
        this.personaPadre = new Persona();
        this.personaMadre = new Persona();
        this.buscarPadre = null;
        this.buscarMadre = null;
        this.tempEstadoPadres = null;
        this.padre = null;
        this.madre = null;
        PadreAlumno tempPadreAlumno = null;

        Session session = HibernateUtil.getSessionFactory().openSession();
        Criteria cPadres = session.createCriteria(PadreAlumno.class);
        cPadres.add(Restrictions.eq("alumno", this.alumno));
        Iterator iter = cPadres.list().iterator();

        while (iter.hasNext()) {
            tempPadreAlumno = (PadreAlumno) iter.next();
            if ("Masculino".equals(tempPadreAlumno.getPadre().getPersona().getVcSexo())) {
                this.padre = tempPadreAlumno.getPadre().getPersona().getVcNombres() + " " + tempPadreAlumno.getPadre().getPersona().getVcApellidos();
                this.tempEstadoPadres = tempPadreAlumno.getPadre().getVcEstadoCivil();
            } else {
                this.madre = tempPadreAlumno.getPadre().getPersona().getVcNombres() + " " + tempPadreAlumno.getPadre().getPersona().getVcApellidos();
            }
        }
        session.close();
    }

    /** Agregar movimiento de retiro, reingreso, etc... a la tabla movimientos de la vista*/
    public void addMovimiento() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        this.estadoAlumno.setVcFecMovimiento(new Date());
        this.alumno = (Alumno) this.selectedAlumno[0];

        String sql = "SELECT vcTipMovimiento FROM Estadoalumno "
                + "WHERE idEstAlumno = (SELECT MAX(idEstAlumno) FROM Estadoalumno "
                + "WHERE vcFecMovimiento = (SELECT MAX(vcFecMovimiento) FROM Estadoalumno WHERE alumno_idAlumno = :id)) ";
        Query query = session.createSQLQuery(sql);
        query.setParameter("id", this.alumno.getIdAlumno());

        try {
            if (this.estadoAlumno.getVcTipMovimiento().equals("Retiro")) {
                if (!"Retiro".equals(query.uniqueResult().toString())) {
                    this.darDeBaja("Inactivo");
                } else {
                    FacesContext.getCurrentInstance().addMessage(null,
                            new FacesMessage(FacesMessage.SEVERITY_ERROR, "Información:", "El alumno esta retirado no puede volver a retirarlo"));
                }
            } else if (this.estadoAlumno.getVcTipMovimiento().equals("Reingreso")) {
                if (!"Reingreso".equals(query.uniqueResult().toString())) {
                    this.darDeAlta();
                } else {
                    FacesContext.getCurrentInstance().addMessage(null,
                            new FacesMessage(FacesMessage.SEVERITY_ERROR, "Información:", "El alumno esta activo no puede reactivarlo"));
                }
            } else if (this.estadoAlumno.getVcTipMovimiento().equals("Egreso")) {
                if (!"Egreso".equals(query.uniqueResult().toString())) {
                    this.darDeBaja("Egresado");
                } else {
                    FacesContext.getCurrentInstance().addMessage(null,
                            new FacesMessage(FacesMessage.SEVERITY_ERROR, "Información:", "El alumno esta egresado no puede volver a egresarlo"));
                }
            } else {
                if (!"Expulsión".equals(query.uniqueResult().toString())) {
                    this.darDeBaja("Expulsado");
                } else {
                    FacesContext.getCurrentInstance().addMessage(null,
                            new FacesMessage(FacesMessage.SEVERITY_ERROR, "Información:", "El alumno esta expulsado no puede volver a expulsarlo"));
                }
            }
            this.nuevo();
        } catch (HibernateException e) {
            FacesUtil.hibernateException(e);
        } finally {
            session.close();
        }
    }

    /** Guarda los cambios*/
    public void confirmarModificacion() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = null;
        try {
            tx = (Transaction) session.beginTransaction();
            session.saveOrUpdate(this.persona);

            Ubicacion tempUbicacion = (Ubicacion) session.load(Ubicacion.class, this.selectedUbicacion);
            this.alumno.setUbicacion(tempUbicacion);
            session.saveOrUpdate(this.alumno);

            /**Eliminar sacramentos para ingresar los nuevos*/
            String sql = "DELETE FROM sacalumno WHERE alumno_idAlumno=:id";
            Query query = session.createSQLQuery(sql);
            query.setParameter("id", this.alumno.getIdAlumno());
            query.executeUpdate();

            if (this.bautismo) {
                Sacalumno tempBautismo = new Sacalumno();
                SacalumnoId idBautismo = new SacalumnoId();
                idBautismo.setAlumnoIdAlumno(this.alumno.getIdAlumno());
                idBautismo.setVcSacramento("Bautismo");
                tempBautismo.setId(idBautismo);
                session.saveOrUpdate(tempBautismo);
            }

            if (this.comunion) {
                Sacalumno tempComunion = new Sacalumno();
                SacalumnoId idComunion = new SacalumnoId();
                idComunion.setAlumnoIdAlumno(this.alumno.getIdAlumno());
                idComunion.setVcSacramento("Comunion");
                tempComunion.setId(idComunion);
                session.saveOrUpdate(tempComunion);
            }

            if (this.confirmacion) {
                Sacalumno tempConfirmacion = new Sacalumno();
                SacalumnoId idConfirmacion = new SacalumnoId();
                idConfirmacion.setAlumnoIdAlumno(this.alumno.getIdAlumno());
                idConfirmacion.setVcSacramento("Confirmacion");
                tempConfirmacion.setId(idConfirmacion);
                session.saveOrUpdate(tempConfirmacion);
            }

            /** Eliminar problemas de salud anteriores para ingresar los nuevos*/
            sql = "DELETE FROM problemasalud WHERE alumno_idAlumno=:id";
            query = session.createSQLQuery(sql);
            query.setParameter("id", this.alumno.getIdAlumno());
            query.executeUpdate();

            if (this.problemasDeSalud.isEmpty() == false) {
                Iterator iter = this.problemasDeSalud.iterator();
                while (iter.hasNext()) {
                    Problemasalud tempProb = (Problemasalud) iter.next();
                    tempProb.setAlumno(this.alumno);
                    session.save(tempProb); /*No se xq pero no funciona el saveOrUpdate solo el save*/
                }
            }
            session.flush();
            session.clear();
            tx.commit();
            this.nuevo(); //Y una vez actualizado todo se limpian las variables...
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO, "Información:", "El alumno se modifico satisfactoriamente"));
        } catch (HibernateException e) {
            tx.rollback();
            FacesUtil.hibernateException(e);
        } finally {
            session.close();
        }
    }

    /** Se usa para retirar, expulsar y egresar*/
    public void darDeBaja(String estado) {
        this.limpiar();
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = null;
        try {
            tx = (Transaction) session.beginTransaction();
            this.alumno = (Alumno) this.selectedAlumno[0];
            this.alumno.setVcEstado(estado);
            session.saveOrUpdate(this.alumno);

            Estadoalumno tempEstado = new Estadoalumno(this.alumno, this.estadoAlumno.getVcTipMovimiento(), new Date(), this.estadoAlumno.getVcRazon());
            session.save(tempEstado);
            session.flush();
            session.clear();
            tx.commit();
            this.nuevo();
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO, "Información:", "El movimiento se realizo satisfactoriamente"));
        } catch (HibernateException e) {
            tx.rollback();
            FacesUtil.hibernateException(e);
        } finally {
            session.close();
        }
    }

    /** Se usa para reactivar al alumno cuando ocurre un reingreso*/
    public void darDeAlta() {
        this.limpiar();
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction tx = null;
        try {
            tx = (Transaction) session.beginTransaction();
            this.alumno = (Alumno) this.selectedAlumno[0];
            this.alumno.setVcEstado("Activo");
            session.saveOrUpdate(this.alumno);

            Estadoalumno tempEstado = new Estadoalumno(this.alumno, this.estadoAlumno.getVcTipMovimiento(), new Date(), this.estadoAlumno.getVcRazon());
            session.save(tempEstado);
            session.flush();
            session.clear();
            tx.commit();
            this.nuevo();
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO, "Información:", "El alumno ha sido reactivado"));
        } catch (HibernateException e) {
            tx.rollback();
            FacesUtil.hibernateException(e);
        } finally {
            session.close();
        }
    }

    /** Limpiar variables*/
    private void limpiar() {
        this.selectedDepartamento = null;
        this.selectedUbicacion = null;
        this.listaUbicaciones = new ArrayList<SelectItem>();
        this.bautismo = false;
        this.comunion = false;
        this.confirmacion = false;
        this.problemasDeSalud = new ArrayList<Problemasalud>();
        this.alumno = new Alumno();
        this.persona = new Persona();
    }

    /** Extraer problemas de salud para el alumno especificamente*/
    private ArrayList<Problemasalud> getProblemasDeSalud(Alumno alumno) {
        ArrayList<Problemasalud> listaProblemas = new ArrayList();
        Session session = HibernateUtil.getSessionFactory().openSession();
        String sql = "SELECT p "
                + "FROM Problemasalud p "
                + "WHERE p.alumno = :id ";
        Query query = session.createQuery(sql);
        query.setParameter("id", alumno);
        listaProblemas = (ArrayList) query.list();
        session.close();
        return listaProblemas;
    }

    /**Extraer todos los sacramentos que al alumno haya recibido*/
    private ArrayList getSacramentosAlumno(Long idAlumno) {
        ArrayList listaSacramentos = new ArrayList();
        Session session = HibernateUtil.getSessionFactory().openSession();
        String sql = "SELECT s.`vcSacramento` FROM alumno a "
                + "JOIN sacalumno s "
                + "ON a.`idAlumno`=s.`alumno_idAlumno` "
                + "WHERE a.`idAlumno`=:id";
        Query query = session.createSQLQuery(sql);
        query.setParameter("id", idAlumno);
        listaSacramentos = (ArrayList) query.list();
        session.close();
        return listaSacramentos;
    }

    /** Extraer el departamento al que pertenece el alumno*/
    private BigInteger getDepartamentoAlumno(Long idAlumno) {
        BigInteger departamento = null;
        Session session = HibernateUtil.getSessionFactory().openSession();
        String sql = "SELECT u.`ubicacion_idUbicacion` "
                + "FROM alumno a, ubicacion u "
                + "WHERE a.idAlumno = :id "
                + "AND a.`ubicacion_idUbicacion`=u.`idUbicacion`";
        Query query = session.createSQLQuery(sql);
        query.setParameter("id", idAlumno);
        departamento = (BigInteger) query.uniqueResult();
        session.close();
        return departamento;
    }

    /** Extraer la ubicacion del alumno*/
    private BigInteger getMunicipioAlumno(Long idAlumno) {
        BigInteger municipio = null;
        Session session = HibernateUtil.getSessionFactory().openSession();
        String sql = "SELECT a.ubicacion_idUbicacion FROM alumno a WHERE a.idAlumno=:id";
        Query query = session.createSQLQuery(sql);
        query.setParameter("id", idAlumno);
        municipio = (BigInteger) query.uniqueResult();
        session.close();
        return municipio;
    }

    /** Muestra los datos de la BD en la tabla*/
    public void populateAlumnos() {
        Session session = HibernateUtil.getSessionFactory().openSession();
        String sql = "SELECT a, p FROM Alumno a "
                + "JOIN a.persona p "
                + "ORDER BY a.idAlumno DESC";

        Query query = session.createQuery(sql);
        this.listaAlumnos = (ArrayList) query.list();
        session.close();
    }

    /** Muestra los datos de la BD en la tabla*/
    public void populateMovimientosAlumno() {
        this.alumno = new Alumno();
        this.estadoAlumno = new Estadoalumno(); //Inicializando variables

        Session session = HibernateUtil.getSessionFactory().openSession();
        this.alumno = (Alumno) this.selectedAlumno[0];

        String sql = "SELECT e FROM Estadoalumno e "
                + "WHERE e.alumno = :alumno "
                + "ORDER BY e.idEstAlumno DESC";
        Query query = session.createQuery(sql);
        query.setParameter("alumno", this.alumno);
        this.listaEstadoAlumnos = (ArrayList) query.list();
        session.close();
    }

    /** Convierte Date a String*/
    public String getStringDate(Date d) {
        return FacesUtil.getStringDate(d);
    }

    /** Para cargar los municipios del departamento que haya sido seleccionado*/
    public void onSelectDepartamento() {
        UbicacionBean n = (UbicacionBean) FacesUtil.getBean("ubicacionBean");
        this.listaUbicaciones = n.cargarListaMunicipios(this.selectedDepartamento);
    }

    /**
     * Carga la lista de departamentos 
     */
    public ArrayList<SelectItem> cargarUbicaciones() {
        ArrayList<SelectItem> lista = new ArrayList<SelectItem>();
        Session session = HibernateUtil.getSessionFactory().openSession();
        String sql = "SELECT u FROM Ubicacion u "
                + "WHERE u.ubicacion IS NULL";
        Query query = session.createQuery(sql);
        Iterator iter = query.list().iterator();

        while (iter.hasNext()) {
            Ubicacion s = (Ubicacion) iter.next();
            lista.add(new SelectItem(s.getIdUbicacion(), s.getVcNombreUbicacion(), ""));
        }
        session.close();
        return lista;
    }

    /** Agregar Problemas de Salud en la tabla*/
    public void addProblema() {
        this.problemasDeSalud.add(this.problemaSalud);
        this.problemaSalud = new Problemasalud();
    }

    /** Quita Problemas de Salud de la tabla*/
    public void removeProblema() {
        this.problemasDeSalud.remove(this.selectedProblema);
    }

    /**
     * Getters & Setters
     */
    public ArrayList getListaAlumnos() {
        return listaAlumnos;
    }

    public void setListaAlumnos(ArrayList listaAlumnos) {
        this.listaAlumnos = listaAlumnos;
    }

    public Persona getPersona() {
        return persona;
    }

    public void setPersona(Persona persona) {
        this.persona = persona;
    }

    public ArrayList<SelectItem> getListaUbicaciones() {
        return listaUbicaciones;
    }

    public void setListaUbicaciones(ArrayList<SelectItem> listaUbicaciones) {
        this.listaUbicaciones = listaUbicaciones;
    }

    public Long getSelectedDepartamento() {
        return selectedDepartamento;
    }

    public void setSelectedDepartamento(Long selectedDepartamento) {
        this.selectedDepartamento = selectedDepartamento;
    }

    public Alumno getAlumno() {
        return alumno;
    }

    public void setAlumno(Alumno alumno) {
        this.alumno = alumno;
    }

    public Object[] getSelectedAlumno() {
        return selectedAlumno;
    }

    public void setSelectedAlumno(Object[] selectedAlumno) {
        this.selectedAlumno = selectedAlumno;
    }

    public Long getSelectedUbicacion() {
        return selectedUbicacion;
    }

    public void setSelectedUbicacion(Long selectedUbicacion) {
        this.selectedUbicacion = selectedUbicacion;
    }

    public Boolean getBautismo() {
        return bautismo;
    }

    public void setBautismo(Boolean bautismo) {
        this.bautismo = bautismo;
    }

    public Boolean getComunion() {
        return comunion;
    }

    public void setComunion(Boolean comunion) {
        this.comunion = comunion;
    }

    public Boolean getConfirmacion() {
        return confirmacion;
    }

    public void setConfirmacion(Boolean confirmacion) {
        this.confirmacion = confirmacion;
    }

    public Problemasalud getProblemaSalud() {
        return problemaSalud;
    }

    public void setProblemaSalud(Problemasalud problemaSalud) {
        this.problemaSalud = problemaSalud;
    }

    public ArrayList<Problemasalud> getProblemasDeSalud() {
        return problemasDeSalud;
    }

    public void setProblemasDeSalud(ArrayList<Problemasalud> problemasDeSalud) {
        this.problemasDeSalud = problemasDeSalud;
    }

    public Problemasalud getSelectedProblema() {
        return selectedProblema;
    }

    public void setSelectedProblema(Problemasalud selectedProblema) {
        this.selectedProblema = selectedProblema;
    }

    public Estadoalumno getEstadoAlumno() {
        return estadoAlumno;
    }

    public void setEstadoAlumno(Estadoalumno estadoAlumno) {
        this.estadoAlumno = estadoAlumno;
    }

    public ArrayList<Estadoalumno> getListaEstadoAlumnos() {
        return listaEstadoAlumnos;
    }

    public void setListaEstadoAlumnos(ArrayList<Estadoalumno> listaEstadoAlumnos) {
        this.listaEstadoAlumnos = listaEstadoAlumnos;
    }

    public Persona getPersonaMadre() {
        return personaMadre;
    }

    public void setPersonaMadre(Persona personaMadre) {
        this.personaMadre = personaMadre;
    }

    public Persona getPersonaPadre() {
        return personaPadre;
    }

    public void setPersonaPadre(Persona personaPadre) {
        this.personaPadre = personaPadre;
    }

    public String getMadre() {
        return madre;
    }

    public void setMadre(String madre) {
        this.madre = madre;
    }

    public String getPadre() {
        return padre;
    }

    public void setPadre(String padre) {
        this.padre = padre;
    }

    public String getBuscarMadre() {
        return buscarMadre;
    }

    public void setBuscarMadre(String buscarMadre) {
        this.buscarMadre = buscarMadre;
    }

    public String getBuscarPadre() {
        return buscarPadre;
    }

    public void setBuscarPadre(String buscarPadre) {
        this.buscarPadre = buscarPadre;
    }

    public String getTempEstadoPadres() {
        return tempEstadoPadres;
    }

    public void setTempEstadoPadres(String tempEstadoPadres) {
        this.tempEstadoPadres = tempEstadoPadres;
    }
}
